Theory Unification in Abstract Clause Graphs

Clause Graphs, as they were defined in the 1970s, are graphs representing first order formulas in conjunctive normal form together with the resolution possibilities. The nodes are labelled with literals and the edges (links) connect complementary unifiable literals. This report describes a generalization of this concept, called abstract clause graphs. The nodes of abstract clause graphs are still labelled with literals, the links however connect literals that are "unifiable" relative to a given relation between literals. This relation is not explicitely defined; only certain "abstract" properties are required. for instance the existence of a special purpose unification algorithm is assumed which computes substitutions, the application of which makes the relation hold for two literals. When instances of already existing literals are added to the graph (e.g. due to resolution or factoring), the links to the new literals are derived from the links of their ancestors. An inheritance mechanism for such links is presented which operates only on the attached substitutions and does not have to unify the literals. This solves a long standing open problem of connection graph calculi: how to inherit links (with several unifiers attached) such that no unifier has to be computed more than once

Using Automated Reasoning Techniques for Deductive Databasis

This report presents a proposal for a deduction component that supports the query mechanism of relational databases. The query-subquery (QSQ) paradigm is currently very popular in the database community since it focuses the deduction process on the relevant data. We show how to extend the QSQ paradigm from Horn clauses to arbitrary predicate logic formulae such that disjunctions in the consequent of an implication, negation in its logical meaning and arbitrary recursive predicates can be handled without restrictions. Various techniques to improve the search behaviour, such as lemma generation, query generalization etc. can be incorporated. Furthermore we show how to use clause graphs for compile time optimizations in the presence of recursive clauses and to support the run time processing

Semantics Based Translation Methods for Modal Logics

A general framework for translating logical formulae from one logic into another logic is presented. The framework is instantiated with two different approaches to translating modal logic formulae into predicate logic. The first one, the well known “relational” translation makes the modal logic’s possible worlds structure explicit by introducing a distinguished predicate symbol to represent the accessibility relation. In the second approach, the “functional” translation method, paths in the possible worlds structure are represented by compositions of functions which map worlds to accessible worlds. On the syntactic level this means that every flexible symbol is parametrized with particular terms denoting whole paths from the initial world to the actual world. The “target logic” for the translation is a first order many sorted logic with built in equality. Therefore the “source logic” may also be first order many sorted with built in equality. Furthermore flexible function symbols are allowed. The modal operators may be parametrized with arbitrary terms and particular properties of the accessibility relation may be specified within the logic itself

Computer Support for the Development and Investigation of Logics

The development and investigation of application--oriented logics comprises many aspects and problems. For a few of them some computer support is possible which frees the investigator from sometimes quite complex computations. This paper gives an overview about some developments in this area. In particular, we consider the correspondences between axiomatic and semantic specifications of a logic and the problem of finding one from the other by means of automated theorem provers and quantifier elimination algorithms. Other topics adressed in this paper are reasoning in Hilbert systems, the investigation of the expressiveness of a logic and the axiomatizability of semantic conditions. For the technical details of the methods and the proofs I refer to the original papers

Implementation: GeTS -- A Specification Language for Geo-Temporal Notions

This document describes the ‘Geo-Temporal’ specification language GeTS. The objects which can be described and manipulated with this language are time points, crisp and fuzzy time intervals and labelled partitionings of the time axis. The partitionings are used to represent periodic temporal notions like months, semesters etc. GeTS is essentially a typed functional language with a few imperative constructs. GeTS can be used to specify and compute with many different kinds of temporal notions, from simple arithmetic operations on time points up to complex fuzzy relations between fuzzy time intervals. The syntax of GeTS together with an operational semantics is described. A parser, a compiler and an abstract machine for GeTS is implemented. The application programming interface for GeTS is documented in the appendix

2.2 Scalar Properties of Fuzzy Time Intervals........................... 5

The FuTIRe library is a collection of classes and methods for representing and manipulating fuzzy time intervals and relations between them. Time intervals like ‘tonight’, which are usually not very precise, can be modeled as fuzzy sets. But this causes the problem that the relations between points and intervals and between two intervals, which are usually very trivial, become very complex when the intervals are fuzzy sets. Moreover, there are many different possibilities to define such relations. In FuTIRe it is not only possible to represent fuzzy time intervals, but one can define customized fuzzy point-interval and interval-interval relations. These relations can even yield fuzzy values when the intervals are in fact crisp. As an example for an application, consider a database with, say, a cinema timetable, and you query the timetable “give me all performances ending before midnight”. The usual ‘before ’ relation will exclude the performances ending a second after midnight. With the fuzzy before relation in FuTIRe you can get instead of a sharp drop to 0 at midnight decreasing fuzzy values after midnight, and these can be used to order the results of the query. FuTIRe is an ope